pgvm 0.1.0__tar.gz → 0.2.0__tar.gz

{pgvm-0.1.0 → pgvm-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvm
-Version: 0.1.0
+Version: 0.2.0
 Summary: PGVM is an abbreviation for Pointer Graph Virtual Machine.
 Author-email: masaniki <masaniki.software@gmail.com>
 License-Expression: MIT

{pgvm-0.1.0 → pgvm-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pgvm"
-version = "0.1.0"
+version = "0.2.0"
 authors = [
   { name="masaniki", email="masaniki.software@gmail.com" },
 ]

pgvm-0.2.0/src/pgvm/editable_graph.py

@@ -0,0 +1,361 @@
+
+import graphviz
+
+from .error import PGVMRuntimeError, PGVMInvalidPath, PGVMSyntaxError
+
+class EditableGraph():
+  """
+  @Summ: 編集可能なgraph構造を与えるclass.
+
+  @Desc:
+  - node番号は非負整数である。負の値はerror用。
+  """
+  PATH_DELIMITER="/"
+
+  def __init__(self,graph,rootNode:int,program:list=None):
+    """
+    @Summ: constructor.
+
+    @InsVars:
+      data:
+        @Summ: {node番号(int):{edgeLabel(str):node番号(int)}}。
+        @Type: Dict
+      rootNode:
+        @Summ: root nodeのnode番号。
+        @Type: Int
+      maxNodeIdx:
+        @Summ: node番号の最大値を記録する。
+        @Type: Int
+      program:
+        @Summ: programのdataを入れる。
+        @Type: Str型二次元配列。
+      programCounter:
+        @Summ: 次に実行するprogramの行番号を記録する。
+        @Desc: 例外messageを出すために必要。
+        @Type: Int
+      programLength:
+        @Summ: 次に実行するprogramの行数を記録する。
+        @Type: Int
+    """
+    self.graph=graph
+    self.rootNode=rootNode
+    self.maxNodeIdx=None
+    self.program=program
+    self.programCounter=0
+    if(program is None):
+      self.programLength=0
+    else:
+      self.programLength=len(program)
+
+  def loadProgramCSV(self,csvFile):
+    """
+    @Summ: programが書かれたCSV fileをloadする関数。
+
+    @Args:
+      csvFile:
+        @Summ: programが書かれたcsv file名。
+        @SemType: str型の二次元配列。
+    """
+    with open(csvFile,mode="r",encoding="utf-8") as f:
+      lineList=f.readlines()
+    programData=[]
+    for line in lineList:
+      if(line[-1]=="\n"):
+        notBreakLine=line[:-1]
+      else:
+        notBreakLine=line
+      argList=notBreakLine.split(",")
+      programData.append(argList)
+    self.program=programData
+    self.programLength=len(programData)
+
+  def visualizeProgram(self,filename):
+    """
+    @Summ: programをgraph構造で可視化する関数。
+    """
+    digraph=graphviz.Digraph()
+    digraph.filename=filename
+    digraph.format="svg"
+    digraph.attr("graph",rankdir="LR")
+    digraph.node(name="start")
+    digraph.node(name="end")
+    digraph.edge("start","row_0:command")
+    for i in range(self.programLength):
+      argList=self.program[i]
+      command=argList[0]
+      match command:
+        case "gn":
+          nodeLabel=f"<command> {command}|{argList[1]}|<jump1> {argList[2]}"
+          if(int(argList[2])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name=f"row_{argList[2]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name="end")
+        case "ge":
+          nodeLabel=f"<command> {command}|{argList[1]}|{argList[2]}|<jump1> {argList[3]}"
+          if(int(argList[3])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name=f"row_{argList[3]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name="end")
+        case "se":
+          nodeLabel=f"<command> {command}|{argList[1]}|{argList[2]}|<jump1> {argList[3]}"
+          if(int(argList[3])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name=f"row_{argList[3]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name="end")
+        case "del":
+          nodeLabel=f"<command> {command}|{argList[1]}|<jump1> {argList[2]}"
+          if(int(argList[2])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name=f"row_{argList[2]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name="end")
+        case "if":
+          nodeLabel=f"<command> {command}|{argList[1]}|{argList[2]}|<jump1> {argList[3]}|<jump2> {argList[4]}"
+          if(int(argList[3])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name=f"row_{argList[3]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump1",head_name="end")
+          if(int(argList[4])<self.programLength):
+            digraph.edge(tail_name=f"row_{i}:jump2",head_name=f"row_{argList[4]}:head")
+          else:
+            digraph.edge(tail_name=f"row_{i}:jump2",head_name="end")
+        case _:
+          raise PGVMSyntaxError(self.programCounter, f"{command} is invalid command.")
+      digraph.node(name=f"row_{i}",label=nodeLabel, shape="record")
+    digraph.render()
+
+
+  def __issueNewNode(self):
+    """
+    @Summ: 新しいnode番号を発行する関数。
+
+    @Desc: 最大値を利用して新しい番号を生成している。
+
+    @Returns:
+      @Summ: 新しいnode番号。
+      @Type: Int
+    """
+    if(self.maxNodeIdx is None):
+      self.maxNodeIdx=max(self.graph.keys())
+    newNodeIdx=self.maxNodeIdx+1
+    self.maxNodeIdx=newNodeIdx
+    self.graph[newNodeIdx]={}
+    return newNodeIdx
+
+  def visualize(self,filename):
+    """
+    @Summ: graphvizで可視化する関数。
+    """
+    digraph=graphviz.Digraph()
+    digraph.filename=filename
+    digraph.format="svg"
+    digraph.attr("graph",rankdir="LR")
+    for nodeIdx,edgeDict in self.graph.items():
+      # print(nodeIdx)
+      digraph.node(str(nodeIdx))
+      for edgeLabel,destNode in edgeDict.items():
+        digraph.edge(tail_name=str(nodeIdx), head_name=str(destNode), label=edgeLabel)
+    digraph.render()
+
+  def accessNode(self,path:list):
+    """
+    @Summ: pathからedgeを参照する関数。
+
+    @Args:
+      path:
+        @Summ: 参照するedge.
+        @SemType: Str型List.
+    @Returns:
+    - @Summ: nodeの到達履歴。
+      @Desc: 到達不可能になったらそこで終了する。
+      @Type: Int型List
+    - @Summ: 使わなかったedgeLabelの数。この数字を未到達度と呼ぶ。
+      @Desc: 0で到達完了を表す。
+      @Type: Int
+    """
+    history=[self.rootNode]
+    curEdgeDict=self.graph[self.rootNode]
+    pathLength=len(path)
+    unreached=pathLength
+    for i in range(pathLength):
+      edgeLabel=path[i]
+      curNode=curEdgeDict.get(edgeLabel)
+      if(curNode is None):
+        break
+      history.append(curNode)
+      curEdgeDict=self.graph[curNode]
+      unreached-=1
+    return history,unreached
+
+
+  def execute(self):
+    """
+    @Summ: programを実行する関数。
+    """
+    self.programCounter=0
+    while(True):
+      if(self.programLength<=self.programCounter):
+        break
+      argList=self.program[self.programCounter]
+      command=argList[0]
+      arglen=len(argList)
+      match command:
+        case "se":
+          if(arglen!=4):
+            raise PGVMSyntaxError(self.programCounter, "the argument count is should be 4.")
+          self.switchEdge(argList[1],argList[2])
+          self.programCounter=int(argList[3])
+        case "del":
+          if(arglen!=3):
+            raise PGVMSyntaxError(self.programCounter, "the argument count is should be 3.")
+          self.executeDeletion(argList[1])
+          self.programCounter=int(argList[2])
+        case "gn":
+          if(arglen!=3):
+            raise PGVMSyntaxError(self.programCounter, "the argument count is should be 3.")
+          self.generateNode(argList[1])
+          self.programCounter=int(argList[2])
+        case "ge":
+          if(arglen!=4):
+            raise PGVMSyntaxError(self.programCounter, "the argument count is should be 4.")
+          self.generateEdge(argList[1],argList[2])
+          self.programCounter=int(argList[3])
+        case "if":
+          if(arglen!=5):
+            raise PGVMSyntaxError(self.programCounter, "the argument count is should be 5.")
+          isSame=self.executeIf(argList[1],argList[2])
+          if(isSame):
+            self.programCounter=int(argList[3])
+          else:
+            self.programCounter=int(argList[4])
+        case _:
+          raise PGVMSyntaxError(self.programCounter, "unknown command.")
+    return
+
+  def executeDeletion(self,path:str):
+    """
+    @Summ: 到達可能なedgeを削除する関数。
+
+    @Args:
+      path:
+        @Summ: 既存のpath。このedgeを削除する。
+        @Type: Str
+    """
+    edgeList=path.split(self.PATH_DELIMITER)
+    lastNodePath=edgeList[:-1]
+    lastEdge=edgeList[-1]
+    history,unreached=self.accessNode(lastNodePath)
+    if(unreached==0):
+      lastNode=history[-1]
+      del self.graph[lastNode][lastEdge]
+    else:
+      raise PGVMInvalidPath(self.programCounter, path)
+
+  def generateNode(self,path):
+    """
+    @Summ: 未知のnodeへの新しいedgeを生成する関数。
+
+    @Args:
+      path:
+        @Summ: 新規生成するpathを表す。
+        @Desc: 未到達度=1である必要がある。
+        @Type: Str
+    """
+    edgeList=path.split(self.PATH_DELIMITER)
+    history,unreached=self.accessNode(edgeList)
+    if(unreached!=1):
+      raise PGVMInvalidPath(self.programCounter, path)
+    lastEdge=edgeList[-1]
+    lastNode=history[-1]
+    newNode=self.__issueNewNode()
+    self.graph[lastNode][lastEdge]=newNode
+
+  def generateEdge(self,path1,path2):
+    """
+    @Summ: 既知のnodeへの新しいedgeを生成する関数。
+
+    @Args:
+      path1:
+        @Summ: 終点を動かすpathを指定する。
+        @Desc: 未知のpathしか受け付けない。
+        @Type: Str
+      path2:
+        @Summ: edgeの新しい終着点を指定する。
+        @Desc: 既知のpathしか受け付けない。
+        @Type: Str
+    """
+    path1EdgeList=path1.split(self.PATH_DELIMITER)
+    path2EdgeList=path2.split(self.PATH_DELIMITER)
+    # self.changeEdgeDestination(path1EdgeList,path2EdgeList)
+    path1history,unused1=self.accessNode(path1EdgeList)
+    lastEdgeLabel=path1EdgeList[-1]
+    if(unused1!=1):
+      raise PGVMInvalidPath(self.programCounter, path1)
+    edgeStartNode=path1history[-1]
+    path2history,unused2=self.accessNode(path2EdgeList)
+    if(unused2>0):
+      raise PGVMInvalidPath(self.programCounter, path2)
+    newEndNode=path2history[-1]
+    self.graph[edgeStartNode][lastEdgeLabel]=newEndNode
+
+  def switchEdge(self,path1,path2):
+    """
+    @Summ: 既知のpathの終点を既知のnodeに切り替える関数。
+
+    @Desc: 始点と終点が同じ辺(二重辺)は禁止。
+
+    @Args:
+      path1:
+        @Summ: 終点を動かすpathを指定する。
+        @Desc: 既知のpathしか受け付けない。
+        @Type: Str
+      path2:
+        @Summ: edgeの新しい終着点を指定する。
+        @Desc: 既知のpathしか受け付けない。
+        @Type: Str
+    """
+    path1EdgeList=path1.split(self.PATH_DELIMITER)
+    path2EdgeList=path2.split(self.PATH_DELIMITER)
+    path1history,unused1=self.accessNode(path1EdgeList)
+    lastEdge=path1EdgeList[-1]
+    if(unused1>0):
+      raise PGVMInvalidPath(self.programCounter, path1)
+    newStartNode=path1history[-2]
+    path2history,unreached2=self.accessNode(path2EdgeList)
+    if(unreached2>0):
+      raise PGVMInvalidPath(self.programCounter, path2)
+    newEndNode=path2history[-1]
+    edgeInfo=self.graph[newStartNode]
+    if(newEndNode in edgeInfo.values()):
+      raise PGVMRuntimeError(self.programCounter, "Edge endpoint is duplicated.")    #既存のedgeの終端が被る。
+    self.graph[newStartNode][lastEdge]=newEndNode
+
+  def executeIf(self,path1,path2):
+    """
+    @Summ: if文を実行する関数。
+
+    @Args:
+      path1:
+        @Summ: if文の第一引数。比較するpathその1。
+        @Type: Str
+      path2:
+        @Summ: if文の第二引数。比較するpathその2。
+        @Type: Str
+    @Returns:
+      @Summ: 同じ値の時にTrue.
+      @Type: Bool
+    """
+    path1EdgeList=path1.split(self.PATH_DELIMITER)
+    path1History,path1unreached=self.accessNode(path1EdgeList)
+    path2EdgeList=path2.split(self.PATH_DELIMITER)
+    path2History,path2unreached=self.accessNode(path2EdgeList)
+    if(path1unreached!=0):
+      raise PGVMInvalidPath(self.programCounter, path1)
+    if(path2unreached!=0):
+      raise PGVMInvalidPath(self.programCounter, path2)
+    path1LastNode=path1History[-1]
+    path2LastNode=path2History[-1]
+    if(path1LastNode==path2LastNode):
+      return True
+    else:
+      return False
+

pgvm-0.2.0/src/pgvm/error.py

@@ -0,0 +1,28 @@
+
+class PGVMRuntimeError(RuntimeError):
+  """
+  @Summ: PGNM用の例外class.
+  """
+  def __init__(self, line:int, message:str):
+    super().__init__()
+    self.line=line
+    self.message=message
+  
+  def __str__(self):
+    return f"line: {self.line}:\n\t{self.message}"
+
+class PGVMInvalidPath(PGVMRuntimeError):
+  """
+  @Summ: pathが参照できない時のerror.
+  """
+  def __init__(self, line:int, path:str):
+    super().__init__(line,message=f"{path} is not accesible.")
+    self.line=line
+    self.path=path
+
+class PGVMSyntaxError(PGVMRuntimeError):
+  """
+  @Summ: PGLの構文解析上のerror.
+  """
+  def __init__(self, line:int, message:str):
+    super().__init__(line,message)

{pgvm-0.1.0 → pgvm-0.2.0}/src/pgvm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pgvm
-Version: 0.1.0
+Version: 0.2.0
 Summary: PGVM is an abbreviation for Pointer Graph Virtual Machine.
 Author-email: masaniki <masaniki.software@gmail.com>
 License-Expression: MIT

{pgvm-0.1.0 → pgvm-0.2.0}/src/pgvm.egg-info/SOURCES.txt

@@ -3,9 +3,10 @@ README.md
 pyproject.toml
 src/pgvm/__init__.py
 src/pgvm/editable_graph.py
+src/pgvm/error.py
 src/pgvm.egg-info/PKG-INFO
 src/pgvm.egg-info/SOURCES.txt
 src/pgvm.egg-info/dependency_links.txt
 src/pgvm.egg-info/requires.txt
 src/pgvm.egg-info/top_level.txt
-tests/test_main.py
+tests/test_graph_execution.py

pgvm-0.2.0/tests/test_graph_execution.py

@@ -0,0 +1,110 @@
+from pathlib import Path
+import sys
+from copy import deepcopy
+
+import yaml
+
+#sys.pathを弄る。
+projectDir=Path(__file__).parent.parent
+packageDir=projectDir/"src"
+sys.path.append(str(packageDir))
+
+from pgvm import EditableGraph
+
+def testSuitExecution(suitDir:Path):
+  """
+  @Summ: suit単位でtestを実行する関数。
+
+  @Desc: isTestのdefault値はtrue.
+
+  @Args:
+    suitDir:
+      @Summ: test suitのdirectory.
+      @Type: Path
+  """
+  suitInputFile=suitDir/"suit_input.yaml"
+  suitOutputFile=suitDir/"suit_output.yaml"
+  with open(suitInputFile,mode="r", encoding="utf-8") as f:
+    inputDict=yaml.safe_load(f)
+  resultDict={"detail":{}}
+  abstract=True
+  defaultConfig=inputDict.get("default")
+  if(defaultConfig is None):
+    defaultConfig={}
+  for caseDir in suitDir.iterdir():
+    if(caseDir.is_file()):
+      continue
+    caseName=caseDir.name
+    # inputDictでfiltering.
+    caseValue=inputDict.get(caseName,{})
+    caseConfig=deepcopy(defaultConfig)
+    for key,value in caseValue.items():
+      caseConfig[key]=value
+    isTest=caseConfig.get("test",False)
+    if(isTest==False):
+      continue
+    else:
+      del caseConfig["test"]
+    result=testCaseExecution(caseDir,**caseConfig)
+    if(result==False):
+      abstract=False
+    resultDict["detail"][caseName]=result
+  resultDict["abstract"]=abstract
+  with open(suitOutputFile,mode="w",encoding="utf-8") as f:
+    yaml.safe_dump(resultDict,f)
+  return
+
+
+def testCaseExecution(caseDir:Path,outputName:str="output.yaml",expectedName:str|None=None,isDetail:bool=False)->bool:
+  """
+  @Summ: caes単位でtestを実行する関数。
+
+  @Args:
+    caseDir:
+      @Summ: test caseのdirectoryを指定する。
+    ouputName:
+      @Summ: 出力するfile名。
+    expectedName:
+      @Summ: 期待する出力file名。
+      @Desc: Noneの時は出力飲みする。
+    isDetail:
+      @Summ: 期待file以外のfileも出力する。
+      @Default: false
+  @Returns:
+    @Summ: 実際出力と期待出力が同じ時にtrue.
+    @Desc: 実際出力するだけの時もtrue.
+  """
+  graphFile=caseDir/"graph.yaml"
+  programFile=caseDir/"program.csv"
+  beforeDot=caseDir/"before.dot"
+  afterDot=caseDir/"after.dot"
+  outputFile=caseDir/outputName
+  with open(graphFile,mode="r",encoding="utf-8") as f:
+    graphDict=yaml.safe_load(f)
+  eg01=EditableGraph(graphDict,10)
+  if(isDetail):
+    eg01.visualize(beforeDot)
+  eg01.loadProgramCSV(programFile)
+  eg01.execute()
+  with open(outputFile,mode="w",encoding="utf-8") as f:
+    yaml.safe_dump(eg01.graph,f)
+  if(isDetail):
+    eg01.visualize(afterDot)
+  # 期待fileと比較する場合。
+  if(expectedName is None):
+    return True
+  else:
+    expectedFile=caseDir/expectedName
+    with open(expectedFile,mode="r",encoding="utf-8") as f:
+      expDict=yaml.safe_load(f)
+    # 2つのdict型を比較する。
+    return expDict==eg01.graph
+
+if(__name__=="__main__"):
+  suitDir=Path(__file__).parent/"graph_execution"
+  caseDir=Path(__file__).parent/"graph_execution"/"invalid_command"
+  # isSuccess=testCaseExecution(caseDir,"expected.yaml",None,True)
+  # print(isSuccess)
+  # testSuitExecution(suitDir)
+  testCaseExecution(caseDir,isDetail=True)
+

pgvm-0.1.0/src/pgvm/editable_graph.py

@@ -1,303 +0,0 @@
-import graphviz
-
-class EditableGraph():
-  """
-  @Summ: 編集可能なgraph構造を与えるclass.
-
-  @Desc:
-  - node番号は非負整数である。負の値はerror用。
-  """
-  ROOT_NODE=0
-  NEW_NODE=1
-  DELETE_NODE=2
-  NEW_EDGE_LABEL="new"
-  DELETE_EDGE_LABEL="delete"
-  PATH_DELIMITER="/"
-
-
-  @classmethod
-  def __initializeGraph(cls):
-    """
-    @Summ: 初期状態のgraphを出力する関数。
-    """
-    initGraph={cls.ROOT_NODE:{"new":cls.NEW_NODE, "delete":cls.DELETE_NODE},
-               cls.NEW_NODE:{},
-               cls.DELETE_NODE:{}           
-    }
-    return initGraph
-
-
-  def __init__(self,data,connectingNode:int,program:list=None):
-    """
-    @Summ: constructor.
-
-    @InsVars:
-      data:
-        @Summ: {node番号(int):{edgeLabel(str):node番号(int)}}。
-        @Type: Dict
-      maxNodeIdx:
-        @Summ: node番号の最大値を記録する。
-        @Type: Int
-      program:
-        @Summ: programのdataを入れる。
-        @Type: Str型二次元配列。
-      programCounter:
-        @Summ: 次に実行するprogramの行番号を記録する。
-        @Desc: 例外messageを出すために必要。
-        @Type: Int
-      programLength:
-        @Summ: 次に実行するprogramの行数を記録する。
-        @Type: Int
-    """
-    initGraph=self.__initializeGraph()
-    initGraph[self.ROOT_NODE]["file"]=connectingNode
-    initGraph|=data
-    self.data=initGraph
-    self.maxNodeIdx=None
-    self.program=program
-    self.programCounter=0
-    if(program is None):
-      self.programLength=0
-    else:
-      self.proramLength=len(program)
-
-  def loadProgramCSV(self,csvFile):
-    """
-    @Summ: programが書かれたCSV fileをloadする関数。
-
-    @Args:
-      csvFile:
-        @Summ: programが書かれたcsv file名。
-        @SemType: str型の二次元配列。
-    """
-    with open(csvFile,mode="r",encoding="utf-8") as f:
-      lineList=f.readlines()
-    programData=[]
-    for line in lineList:
-      if(line[-1]=="\n"):
-        notBreakLine=line[:-1]
-      else:
-        notBreakLine=line
-      argList=notBreakLine.split(",")
-      programData.append(argList)
-    self.program=programData
-    self.programLength=len(programData)
-
-  def __issueNewNode(self):
-    """
-    @Summ: 新しいnode番号を発行する関数。
-
-    @Desc: 最大値を利用して新しい番号を生成している。
-
-    @Returns:
-      @Summ: 新しいnode番号。
-      @Type: Int
-    """
-    if(self.maxNodeIdx is None):
-      self.maxNodeIdx=max(self.data.keys())
-    newNodeIdx=self.maxNodeIdx+1
-    self.maxNodeIdx=newNodeIdx
-    self.data[newNodeIdx]={}
-    return newNodeIdx
-
-  def visualize(self,filename):
-    """
-    @Summ: graphvizで可視化する関数。
-    """
-    graph=graphviz.Digraph()
-    graph.filename=filename
-    graph.format="svg"
-    graph.attr("graph",rankdir="LR")
-    for nodeIdx,edgeDict in self.data.items():
-      # print(nodeIdx)
-      graph.node(str(nodeIdx))
-      for edgeLabel,destNode in edgeDict.items():
-        graph.edge(tail_name=str(nodeIdx), head_name=str(destNode), label=edgeLabel)
-    graph.render()
-
-  def accessNode(self,path:list):
-    """
-    @Summ: pathからedgeを参照する関数。
-
-    @Args:
-      path:
-        @Summ: 参照するedge.
-        @SemType: Str型List.
-    @Returns:
-    - @Summ: nodeの到達履歴。
-      @Desc: 到達不可能になったらそこで終了する。
-      @Type: Int型List
-    - @Summ: 使わなかったedgeLabelの数。この数字を未到達度と呼ぶ。
-      @Desc: 0で到達完了を表す。
-      @Type: Int
-    """
-    history=[self.ROOT_NODE]
-    curEdgeDict=self.data[self.ROOT_NODE]
-    pathLength=len(path)
-    unreached=pathLength
-    for i in range(pathLength):
-      edgeLabel=path[i]
-      curNode=curEdgeDict.get(edgeLabel)
-      if(curNode is None):
-        break
-      history.append(curNode)
-      curEdgeDict=self.data[curNode]
-      unreached-=1
-    return history,unreached
-
-  def changeEdgeDestination(self,oldPath,newPath):
-    """
-    @Summ: edgeの終点を変更する関数。
-
-    @Desc:
-    - nodeの生成を伴わないedgeの生成まではできる。
-    - 始点と終点が同じ辺(二重辺)は禁止。
-
-    @Args:
-      oldPath:
-        @Summ: 現在のedgeの終着点。
-        @Desc:
-        - 未到達度0の時は、既存のedgeの終点を付け替える作業。
-        - 未到達度1の時は、新しいedgeLabelを生成する。
-        - それ以上の未到達度は受け付けない。
-        @SemType: Str型List.
-      newPath:
-        @Summ: edgeの新しい終着点を指定する。
-        @Desc: 未到達度0のpathしか受け付けない。
-        @SemType: Str型List.
-    """
-    oldDestHistory,oldUnused=self.accessNode(oldPath)
-    lastEdgeLabel=oldPath[-1]
-    if(oldUnused==0):
-      edgeStartNode=oldDestHistory[-2]  
-    elif(oldUnused==1):
-      edgeStartNode=oldDestHistory[-1]
-    else:
-      raise RuntimeError(f"line: {self.programCounter}:\n\t{oldPath} is not accessable.")
-    newDestHistory,newUnused=self.accessNode(newPath)
-    if(newUnused>0):
-      raise RuntimeError(f"line: {self.programCounter}:\n\t{newPath} is not accessable.")
-    newEndNode=newDestHistory[-1]
-    edgeInfo=self.data[edgeStartNode]
-    if(newEndNode in edgeInfo.values()):
-      raise RuntimeError(f"line: {self.programCounter}:\n\t Edge endpoint is duplicated.")    #既存のedgeの終端が被る。
-    self.data[edgeStartNode][lastEdgeLabel]=newEndNode
-
-  def deleteEdge(self,path):
-    """
-    @Summ: 到達可能なedgeを削除する関数。
-
-    @Args:
-      path:
-        @Summ: 削除するedge.
-        @SemType: Str型List.
-    """
-    lastNodePath=path[:-1]
-    lastEdge=path[-1]
-    history,unreached=self.accessNode(lastNodePath)
-    if(unreached==0):
-      lastNode=history[-1]
-      del self.data[lastNode][lastEdge]
-    else:
-      raise RuntimeError(f"line: {self.programCounter}:\n\t{path} is not accessable.")
-
-  def generateEdge(self,path):
-    """
-    @Summ: nodeの生成を伴うedgeの生成を行う関数。
-
-    @Args:
-      path:
-        @Summ: 新しく生成するpath.
-        @Desc: 未到達度=1である必要がある。
-        @SemType: Str型List.
-    """
-    history,unreached=self.accessNode(path)
-    if(unreached!=1):
-      raise RuntimeError(f"line: {self.programCounter}:\n\t{path} is not accessable.")
-    lastEdge=path[-1]
-    lastNode=history[-1]
-    newNode=self.__issueNewNode()
-    self.data[lastNode][lastEdge]=newNode
-
-  def execute(self):
-    """
-    @Summ: programを実行する関数。
-    """
-    self.programCounter=0
-    while(True):
-      if(self.programLength<=self.programCounter):
-        break
-      argList=self.program[self.programCounter]
-      if(argList[0]=="cp"):
-        self.executeCopy(argList[1],argList[2])
-        self.programCounter=int(argList[3])
-        continue
-      elif(argList[0]=="if"):
-        isSame=self.executeIf(argList[1],argList[2])
-        if(isSame):
-          self.programCounter=int(argList[3])
-        else:
-          self.programCounter=int(argList[4])
-    return
-
-  def executeCopy(self,path1,path2):
-    """
-    @Summ: copy文を実行する関数。
-
-    @Args:
-      path1:
-        @Summ: copy文の第一引数。編集するpathを表す。
-        @Type: Str
-      path2:
-        @Summ: copy文の第二引数。上書きするpathを表す。
-        @Type: Str
-    """
-    path1EdgeList=path1.split(self.PATH_DELIMITER)
-    if(path2==self.NEW_EDGE_LABEL):
-      self.generateEdge(path1EdgeList)
-    elif(path2==self.DELETE_EDGE_LABEL):
-      self.deleteEdge(path1EdgeList)
-    else:
-      path2EdgeList=path2.split(self.PATH_DELIMITER)
-      self.changeEdgeDestination(path1EdgeList,path2EdgeList)
-
-  def executeIf(self,path1,path2):
-    """
-    @Summ: if文を実行する関数。
-
-    @Desc:
-    - path1==未到達度1∧path2==DELETE_NODEの時、edgeが存在しない時にTrueを出力する。
-
-    @Args:
-      path1:
-        @Summ: if文の第一引数。比較するpathその1。
-        @Type: Str
-      path2:
-        @Summ: if文の第二引数。比較するpathその2。
-        @Type: Str
-    @Returns:
-      @Summ: 同じ値の時にTrue.
-      @Type: Bool
-    """
-    path1EdgeList=path1.split(self.PATH_DELIMITER)
-    path1History,path1unreached=self.accessNode(path1EdgeList)
-    if(path2==self.DELETE_EDGE_LABEL):
-      if(path1unreached==0):
-        return False
-      elif(path1unreached==1):
-        return True
-      else:
-        raise RuntimeError(f"line {self.programCounter}:\n\t{path2} is not accessable.")
-    path2EdgeList=path2.split(self.PATH_DELIMITER)
-    path2History,path2unreached=self.accessNode(path2EdgeList)
-    if(path1unreached!=0):
-      raise RuntimeError(f"line {self.programCounter}:\n\t{path1} is not accessable.")
-    if(path2unreached!=0):
-      raise RuntimeError(f"line {self.programCounter}:\n\t{path2} is not accessable.")
-    path1LastNode=path1History[-1]
-    path2LastNode=path2History[-1]
-    if(path1LastNode==path2LastNode):
-      return True
-    else:
-      return False
-

pgvm-0.1.0/tests/test_main.py

@@ -1,124 +0,0 @@
-from pathlib import Path
-import sys
-
-#sys.pathを弄る。
-projectDir=Path(__file__).parent.parent.parent
-sys.path.append(str(projectDir))
-
-from library import module1
-
-testDir=Path(__file__).parent/"test"
-
-def test_example_file(exampleName:str,outName:str=None,isTest:bool=None)->bool:
-    """
-    Abst: 1つの事例をtestする関数。
-
-    Expl: 入力dataや出力dataがfileの場合。
-
-    Args:
-        exampleName(str): test caseのdirecotry名。
-        outName(str): 出力先のfile名。拡張子は不要。
-        isTest(bool): 期待出力と実際出力を比較する⇒True。
-    Returns:
-        bool: 期待通りの出力⇒True。
-    """
-    if(outName is None):
-        outName="output"
-    if(isTest is None):
-        isTest=True
-    exampleDir=testDir/exampleName
-    inFile=exampleDir/"input.txt"
-    outFile=exampleDir/f"{outName}.txt"
-    expFile=exampleDir/"expected.txt"
-    parser1=module1()
-    tree=parser1.parseFromFile(inFile)
-    with open(outFile,mode="w",encoding="utf-8") as f:
-        f.write(tree.pretty())
-    if(isTest):
-        with open(outFile,mode="r",encoding="utf-8") as f:
-            outText=f.read()
-        with open(expFile,mode='r',encoding="utf-8") as f:
-            expText=f.read()
-        return outText==expText
-
-def test_example_dir(exampleName:str,outName:str=None,isTest:bool=None)->bool:
-    """
-    Abst: 1つの事例をtestする関数。
-
-    Expl: 入力dataや出力dataがdirectoryの場合。
-
-    Args:
-        exampleName(str): test caseのdirecotry名。
-        outName(str): 出力先のfile名。拡張子は不要。
-        isTest(bool): 期待出力と実際出力を比較する⇒True。
-    Returns:
-        bool: 期待通りの出力⇒True。
-    """
-    if(outName is None):
-        outName="output"
-    if(isTest is None):
-        isTest=True
-    exampleDir=testDir/exampleName
-    inDir=exampleDir/"in"
-    inFile=inDir/"in.txt"
-    outDir=exampleDir/f"{outName}"
-    if(not outDir.is_dir()):
-        outDir.mkdir()
-    outFile=outDir/"out.txt"
-    expDir=exampleDir/"exp"
-    expFile=expDir/"exp.txt"
-    parser1=module1()
-    tree=parser1.parseFromFile(inFile)
-    with open(outFile,mode="w",encoding="utf-8") as f:
-        f.write(tree.pretty())
-    if(isTest):
-        with open(outFile,mode="r",encoding="utf-8") as f:
-            outText=f.read()
-        with open(expFile,mode='r',encoding="utf-8") as f:
-            expText=f.read()
-        return outText==expText   
-
-
-def test_all(outName:str=None,isTest:bool=None)->dict:
-    """
-    Abst: 全てのtest caseをtestする関数。
-
-    Args:
-        outName(str): 出力先のfile名。拡張子は不要。
-        isTest(bool): 期待出力と実際出力を比較する⇒True。
-    Returns:
-        dict: {testCase名(str):真理値(bool)}
-    """
-    resultDict={}
-    for exampleDir in testDir.iterdir():
-        exampleName=exampleDir.name
-        result=test_example_dir(exampleName,outName=outName,isTest=isTest)
-        resultDict[exampleName]=result
-    return resultDict
-
-def test_clear(deleteList:list):
-    """
-    Abst: test caseのdirectoryを綺麗にする関数。
-
-    Expl: fileの削除にしか対応していない。
-
-    Notes: blacklist方式にすることで、意図しないfile削除を起こさないようにしている。
-
-    Args:
-        deleteList(list): 削除するfile名のlist。file名はexample directoryからの相対pathで指定する。
-    """
-    for exampleDir in testDir.iterdir():
-        for fileDir in exampleDir.iterdir():
-            fileName=fileDir.name
-            if(fileName in deleteList):
-                fileDir.unlink()
-
-
-if(__name__=="__main__"):
-    tup=("case2", 70)
-    x=tup[0]
-    y=tup[1]
-    test_example_file("case01","out",isTest=False)
-    # test_all("out",isTest=False)
-
-