app/tasks/minetestcheck/tree.py

   1 import os
   2 from . import MinetestCheckError, ContentType
   3 from .config import parse_conf
   4
   5 def get_base_dir(path):
   6         if not os.path.isdir(path):
   7                 raise IOError("Expected dir")
   8
   9         root, subdirs, files = next(os.walk(path))
  10         if len(subdirs) == 1 and len(files) == 0:
  11                 return get_base_dir(path + "/" + subdirs[0])
  12         else:
  13                 return path
  14
  15
  16 def detect_type(path):
  17         if os.path.isfile(path + "/game.conf"):
  18                 return ContentType.GAME
  19         elif os.path.isfile(path + "/init.lua"):
  20                 return ContentType.MOD
  21         elif os.path.isfile(path + "/modpack.txt") or \
  22                         os.path.isfile(path + "/modpack.conf"):
  23                 return ContentType.MODPACK
  24         elif os.path.isdir(path + "/mods"):
  25                 return ContentType.GAME
  26         elif os.path.isfile(path + "/texture_pack.conf"):
  27                 return ContentType.TXP
  28         else:
  29                 return ContentType.UNKNOWN
  30
  31
  32 class PackageTreeNode:
  33         def __init__(self, baseDir, relative, author=None, repo=None, name=None):
  34                 print(baseDir)
  35                 self.baseDir  = baseDir
  36                 self.relative = relative
  37                 self.author   = author
  38                 self.name        = name
  39                 self.repo        = repo
  40                 self.meta        = None
  41                 self.children = []
  42
  43                 # Detect type
  44                 self.type = detect_type(baseDir)
  45                 self.read_meta()
  46
  47                 if self.type == ContentType.GAME:
  48                         if not os.path.isdir(baseDir + "/mods"):
  49                                 raise MinetestCheckError(("game at {} does not have a mods/ folder").format(self.relative))
  50                         self.add_children_from_mod_dir(baseDir + "/mods")
  51                 elif self.type == ContentType.MODPACK:
  52                         self.add_children_from_mod_dir(baseDir)
  53
  54         def getMetaFilePath(self):
  55                 filename = None
  56                 if self.type == ContentType.GAME:
  57                         filename = "game.conf"
  58                 elif self.type == ContentType.MOD:
  59                         filename = "mod.conf"
  60                 elif self.type == ContentType.MODPACK:
  61                         filename = "modpack.conf"
  62                 elif self.type == ContentType.TXP:
  63                         filename = "texture_pack.conf"
  64                 else:
  65                         return None
  66
  67                 return self.baseDir + "/" + filename
  68
  69
  70         def read_meta(self):
  71                 result = {}
  72
  73                 # .conf file
  74                 try:
  75                         with open(self.getMetaFilePath(), "r") as myfile:
  76                                 conf = parse_conf(myfile.read())
  77                                 for key, value in conf.items():
  78                                         result[key] = value
  79                 except IOError:
  80                         pass
  81
  82                 # description.txt
  83                 if not "description" in result:
  84                         try:
  85                                 with open(self.baseDir + "/description.txt", "r") as myfile:
  86                                         result["description"] = myfile.read()
  87                         except IOError:
  88                                 pass
  89
  90                 # depends.txt
  91                 import re
  92                 pattern = re.compile("^([a-z0-9_]+)\??$")
  93                 if not "depends" in result and not "optional_depends" in result:
  94                         try:
  95                                 with open(self.baseDir + "/depends.txt", "r") as myfile:
  96                                         contents = myfile.read()
  97                                         soft = []
  98                                         hard = []
  99                                         for line in contents.split("\n"):
 100                                                 line = line.strip()
 101                                                 if pattern.match(line):
 102                                                         if line[len(line) - 1] == "?":
 103                                                                 soft.append( line[:-1])
 104                                                         else:
 105                                                                 hard.append(line)
 106
 107                                         result["depends"] = hard
 108                                         result["optional_depends"] = soft
 109
 110                         except IOError:
 111                                 pass
 112
 113                 else:
 114                         if "depends" in result:
 115                                 result["depends"] = [x.strip() for x in result["depends"].split(",")]
 116                         if "optional_depends" in result:
 117                                 result["optional_depends"] = [x.strip() for x in result["optional_depends"].split(",")]
 118
 119                 # Calculate Title
 120                 if "name" in result and not "title" in result:
 121                         result["title"] = result["name"].replace("_", " ").title()
 122
 123                 # Calculate short description
 124                 if "description" in result:
 125                         desc = result["description"]
 126                         idx = desc.find(".") + 1
 127                         cutIdx = min(len(desc), 200 if idx < 5 else idx)
 128                         result["short_description"] = desc[:cutIdx]
 129
 130                 if "name" in result:
 131                         self.name = result["name"]
 132                         del result["name"]
 133
 134                 self.meta = result
 135
 136         def add_children_from_mod_dir(self, dir):
 137                 for entry in next(os.walk(dir))[1]:
 138                         path = os.path.join(dir, entry)
 139                         if not entry.startswith('.') and os.path.isdir(path):
 140                                 child = PackageTreeNode(path, self.relative + entry + "/", name=entry)
 141                                 if not child.type.isModLike():
 142                                         raise MinetestCheckError(("Expecting mod or modpack, found {} at {} inside {}") \
 143                                                         .format(child.type.value, child.relative, self.type.value))
 144
 145                                 self.children.append(child)
 146
 147         def getModNames(self):
 148                 return self.fold("name", type=ContentType.MOD)
 149
 150         # attr: Attribute name
 151         # key: Key in attribute
 152         # retval: Accumulator
 153         # type: Filter to type
 154         def fold(self, attr, key=None, retval=None, type=None):
 155                 if retval is None:
 156                         retval = set()
 157
 158                 # Iterate through children
 159                 for child in self.children:
 160                         child.fold(attr, key, retval, type)
 161
 162                 # Filter on type
 163                 if type and type != self.type:
 164                         return retval
 165
 166                 # Get attribute
 167                 at = getattr(self, attr)
 168                 if not at:
 169                         return retval
 170
 171                 # Get value
 172                 value = at if key is None else at.get(key)
 173                 if isinstance(value, list):
 174                         retval |= set(value)
 175                 elif value:
 176                         retval.add(value)
 177
 178                 return retval
 179
 180         def get(self, key):
 181                 return self.meta.get(key)
 182
 183         def validate(self):
 184                 for child in self.children:
 185                         child.validate()